/**
 * @time 2021/08/20
 * @description 嵌套表格
 * @notes1 共用表头，展开数据放在列数据的children中
 * @notes2 不同表头，展开数据放在列数据的nestedConfig中，nestedConfig可接收参数适配TableC参数
 * @notes3 设置 column.ellipsis 可以让单元格内容根据宽度自动省略。 列头缩略暂不支持和排序筛选一起使用。antd 3.24.0 之后支持
 */
/* eslint-disable */
import React from 'react';
import PropTypes from 'prop-types';

import { CaretDownOutlined, CaretRightOutlined, ExclamationCircleOutlined, QuestionCircleOutlined } from '@ant-design/icons';

import { Table, Popconfirm, Spin, Tooltip, Checkbox } from 'antd';
import { PrimaryGhostC } from '@/src/components';
import accounting from 'accounting';
import { connect } from 'dva';
import TableC from './table';
import BasicTable from './basicTable';
import SiderMenuWidth from '../../css/frame';
import nestedStyle from './nestedTableC.less';
import styles from './table.less';
import pic from '@/src/assets/comps/table/noData.png';
import moment from 'moment';
import filterIcon from '../../assets/icon/icon_filter_normal.png';
import filterIconHover from '../../assets/icon/icon_filter_hover.png';
import { isContainArr, isContainArrOne } from '../../utils/utils';
import classNames from 'classnames';

const CheckboxGroup = Checkbox.Group;

const siderWidth = SiderMenuWidth.width - SiderMenuWidth.collapsedWidth;
class NestedTableC extends React.Component {
  // props默认值
  static defaultProps = {
    columns: undefined,
    dataSource: undefined,
    defaultCurrent: undefined, // 默认第一页
    current: undefined,
    total: 0, // 默认共0条数据
    pageSize: 20, // 默认一页20条
    pageSizeOptions: ['10', '20', '50', '100'], // 默认可选的一页条数
    onShowSizeChange: (current, size) => {}, // pageSize变化时的回调
    onPageChange: (page, pageSize) => {}, // 页码改变的回调，参数是改变后的页码及每页条数
    scroll: undefined, // 横向或纵向滚动条
    hidePage: false, // 默认不隐藏页码
    width: '100%', // 默认占父容器100%
    onChange: () => {}, // 表格所有的操作变化时 回调
    onExpand: () => {}, // 点击展开图标时触发
    bordered: false, // 是否展示外边框和列
    expandedRowKeys: undefined, // 展开的节点
    rowKey: '', // 设置唯一的key
    rowClassName: '', // 设置行样式
    loading: false,
    simple: false, // 简单分页
    showHeader: true, // 默认展示表头
    footer: null,
    commonHeader: false,
    nestedTableChange: () => {},
    fixedChild: false, // 子表格固定宽度展示
    widthKey: '100px', // 涨跌柱的width
    components: {}, // 表格局部修改渲染
    defaultExpandAllRows: false, // 默认不展开子节点
    defaultExpandedRowKeys: undefined, // 默认展开的子节点
    bigTable: false, // 是否是大数据表格
  };

  state = {
    collapsed: undefined, // 侧边菜单栏是否合并
    multiHeader: false, // 是否为多表头
  };

  componentDidMount() {
    this.props.columns &&
      this.props.columns.forEach((element) => {
        if (element.children && element.children.length > 0) {
          this.setState({
            multiHeader: true,
          });
        }
      });
  }

  static getDerivedStateFromProps(nextProps, prevState) {
    let flag;
    if (nextProps.columns && nextProps?.columns.length) {
      for (let i = 0; i < nextProps?.columns.length; i++) {
        const element = nextProps?.columns[i];
        if (element.children && element.children.length > 0) {
          flag = true;
        }
      }
      if (flag !== undefined) {
        return {
          multiHeader: flag,
        };
      }
    }
    return null;
  }

  componentDidUpdate(prevProps, prevState, snapshot) {
    if (this.props.globalM.collapsed !== undefined && this.props.globalM.collapsed !== this.state.collapsed) {
      this.setState(
        {
          collapsed: this.props.globalM.collapsed,
        },
        () => {
          this.getTableDom(this.state.collapsed);
          /** 窗口改变大小时触发 */
          window.onresize = () => {
            this.getTableDom(this.state.collapsed, 'noCalc');
          };
        },
      );
    }
  }

  // 获取表格dom
  getTableDom = (collapsed, type) => {
    let tempWidth;
    if (this.refs.table) {
      clearInterval(this.timerGetDom);
      this.timerGetDom = null;
      if (type || !this.state.width) {
        // 窗口变化、页面初始化时不额外进行计算宽度
        tempWidth = this.refs.table.offsetWidth;
      } else {
        // 收缩侧边菜单 宽度进行增减
        tempWidth = collapsed ? this.refs.table.offsetWidth + siderWidth : this.refs.table.offsetWidth - siderWidth;
      }
    } else {
      clearInterval(this.timerGetDom);
      this.timerGetDom = setTimeout(() => {
        this.getTableDom(collapsed);
      }, 500);
    }

    this.setState({
      width: tempWidth,
    });
  };

  // 图标的展开与收起
  customExpandIcon = (props) => {
    const { commonHeader } = this.props;
    if ((props.record && props.record.children && props.record.children.length > 0) || !commonHeader) {
      if (props.expanded) {
        return (
          <span
            style={{ color: 'black', marginRight: 8 }}
            onClick={(e) => {
              props.onExpand(props.record, e);
            }}
          >
            <CaretDownOutlined style={{ fontSize: 14, color: '#4e86ff' }} />
          </span>
        );
      } else {
        return (
          <span
            style={{ color: 'black', marginRight: 8 }}
            onClick={(e) => {
              props.onExpand(props.record, e);
            }}
          >
            <CaretRightOutlined style={{ color: '#4e86ff' }} />
          </span>
        );
      }
    } else {
      return <span style={{ marginRight: 8 }}></span>;
    }
  };

  // 获取数据最大值
  selectMax = (data, dataIndex, maxValue = 0) => {
    let max = maxValue;
    data.map((item) => {
      const value = item[dataIndex] ? parseFloat(item[dataIndex]) : 0;
      max = max > Math.abs(value) ? max : Math.abs(value);
      if (item.children && item.children.length > 0) {
        max = this.selectMax(item.children, dataIndex, max);
      }
    });
    return max;
  };

  // 显示表格涨跌柱
  handleCompareNum = (text, dataIndex) => {
    const { dataSource, widthKey } = this.props;
    const max = this.selectMax(dataSource, dataIndex);
    const upPer = (Number(Math.abs(text)) / max) * 100;
    return (
      <div style={{ display: 'flex', justifyContent: 'space-between' }} className={styles.dataColumn}>
        <div style={{ display: 'flex', width: widthKey }}>
          <div style={{ width: '50%' }} className='downWrapContainer'>
            {text < 0 ? (
              <>
                <div style={{ width: `${upPer}%` }} className='downWraps'></div>
              </>
            ) : (
              ''
            )}
          </div>
          <div style={{ width: '50%' }} className='upWrapContainer'>
            {text >= 0 ? (
              <>
                <div style={{ width: `${upPer}%` }} className='upWraps'>
                  {' '}
                </div>
              </>
            ) : (
              ''
            )}
          </div>
        </div>
        <div className='recordSpan' title={text}>
          <span>{text}</span>
        </div>
      </div>
    );
  };

  // 筛选下拉选择
  renderFilterOptions = ({ setSelectedKeys, selectedKeys, confirm, clearFilters }, element) => {
    const { dataSource } = this.props;
    const tempArr = dataSource || [];
    const plainOptions = [...new Set(tempArr.map((item) => item[element.key]))];
    return (
      <div className={styles.colFilterBox}>
        <div className={'selectAllBox'}>
          <Checkbox
            indeterminate={selectedKeys?.length && isContainArr(selectedKeys, plainOptions) ? false : isContainArrOne(plainOptions, selectedKeys)}
            checked={selectedKeys?.length && isContainArr(selectedKeys, plainOptions)}
            onChange={(e) => {
              if (e.target.checked) {
                setSelectedKeys(plainOptions);
              } else {
                setSelectedKeys([]);
              }
            }}
          >
            全选
          </Checkbox>
        </div>
        <div style={{ padding: '8px 0' }}>
          <CheckboxGroup
            options={plainOptions}
            value={selectedKeys}
            onChange={(e) => {
              setSelectedKeys(Array.isArray(e) ? e : []);
            }}
          />
        </div>
        <div className={'confirmBox'}>
          <span
            className={'confirmPopBtn'}
            onClick={() => {
              confirm();
            }}
          >
            确认
          </span>
          <span
            className={'confirmPopBtn'}
            onClick={() => {
              clearFilters();
              confirm();
            }}
          >
            重置
          </span>
        </div>
      </div>
    );
  };

  render() {
    const {
      components,
      commonHeader,
      footer,
      showHeader,
      defaultExpandAllRows,
      columns,
      size,
      simple,
      dataSource,
      total,
      defaultCurrent,
      pageSizeOptions,
      onShowSizeChange,
      onPageChange,
      scroll,
      hidePage,
      width,
      onChange,
      rowKey,
      onExpand,
      expandedRowKeys,
      current,
      pageSize,
      rowClassName,
      onRow,
      rowSelection,
      loading,
      bordered,
      onChildExpand,
      nestedTableChange,
      fixedChild,
      defaultExpandedRowKeys,
      bigTable,
    } = this.props;
    columns &&
      columns.forEach((element, index) => {
        // 为每一列添加dataIndex
        element.dataIndex = element.key;
        // 如果有子节点，也为每个子节点添加dataIndex
        element.children && element.children.forEach((item) => (item.dataIndex = item.key));
        // 设置最后一列居右
        if (index == columns.length - 1) {
          element.align = element.align ? element.align : 'right';
        }
        if (element.children) {
          // 如果有子节点，也为每个子节点设置数据格式
          element.children.forEach((item) => {
            // 数字居右
            if (item.type === 'number') {
              item.align = item.align ? item.align : 'right';
              if (item.render === undefined) {
                item.render = (text, record, index) => {
                  if (text === null || text === undefined) {
                    return '--';
                  } else if (text == '我不要数据') {
                    return '';
                  } else if (isNaN(text)) {
                    return text;
                  } else {
                    return accounting.formatNumber(Number(text), item.toFixed ? item.toFixed : item.toFixed == 0 ? 0 : 2); //
                  }
                };
              }
            }
            // 正红负绿 千分位格式，默认保留两位小数
            if (item.type === 'color') {
              item.align = item.align ? item.align : 'right';
              if (item.render === undefined) {
                item.render = (text, record, index) => {
                  if (text === null || text === undefined) {
                    return '--';
                  } else if (text == '我不要数据') {
                    return '';
                  } else if (isNaN(text)) {
                    return text;
                  } else {
                    return (
                      <div style={{ color: text > 0 ? 'red' : text < 0 ? 'green' : '', display: 'flex', float: 'right' }}>
                        {accounting.formatNumber(Number(text), item.toFixed || item.toFixed == 0 ? item.toFixed : 2)}
                        {item.needPercent ? '%' : ''}
                      </div>
                    );
                  }
                };
              }
            }
            // 金钱（千分位格式，默认保留2位小数，支持通过toFixed修改保留位数）
            if (item.type === 'money') {
              item.align = item.align ? item.align : 'right';
              if (item.render === undefined) {
                item.render = (text, record, index) => {
                  if (text === null || text === undefined) {
                    return '--';
                  } else {
                    return accounting.formatNumber(Number(text), item.toFixed ? item.toFixed : 2);
                  }
                };
              }
            }
            // 比率（%格式，默认保留2位小数，支持通过toFixed修改保留位数）
            if (item.type === 'rate') {
              item.align = item.align ? item.align : 'right';
              if (item.render === undefined) {
                item.render = (text, record, index) => {
                  if (text === null || text === undefined) {
                    return '--';
                  } else {
                    // NaN: Not a Number
                    // isNaN()的缺点就在于 null、空格以及空串会被按照0来处理
                    if (isNaN(text)) {
                      return text;
                    } else {
                      return `${(Number(text) * 100).toFixed(item.toFixed ? item.toFixed : 2)}%`;
                    }
                  }
                };
              }
            }
          });
        }
        // 数字居右
        if (element.type === 'number') {
          element.align = element.align ? element.align : 'right';
          if (element.render === undefined) {
            element.render = (text, record, index) => {
              if (text === null || text === undefined) {
                return '--';
              } else if (text == '我不要数据') {
                return '';
              } else if (isNaN(text)) {
                return text;
              } else {
                return accounting.formatNumber(Number(text), element.toFixed ? element.toFixed : element.toFixed == 0 ? 0 : 2); // number类型默认保留2位小数，整数输入0
              }
            };
          }
        }
        // 正红负绿 千分位格式，默认保留两位小数
        if (element.type === 'color') {
          element.align = element.align ? element.align : 'right';
          if (element.render === undefined) {
            element.render = (text, record, index) => {
              if (text === null || text === undefined) {
                return '--';
              } else if (text == '我不要数据') {
                return '';
              } else if (isNaN(text)) {
                return text;
              } else {
                return (
                  <div style={{ color: text > 0 ? 'red' : text < 0 ? 'green' : '', display: 'flex', float: 'right' }}>
                    {accounting.formatNumber(Number(text), element.toFixed || element.toFixed == 0 ? element.toFixed : 2)}
                    {element.needPercent ? '%' : ''}
                  </div>
                );
              }
            };
          }
        }
        // 金钱（千分位格式，默认保留2位小数，支持通过toFixed修改保留位数）
        if (element.type === 'money') {
          element.align = element.align ? element.align : 'right';
          if (element.render === undefined) {
            element.render = (text, record, index) => {
              if (text === null || text === undefined) {
                return '--';
              } else {
                return accounting.formatNumber(Number(text), element.toFixed ? element.toFixed : 2);
              }
            };
          }
        }
        // 比率（%格式，默认保留2位小数，支持通过toFixed修改保留位数）
        if (element.type === 'rate') {
          element.align = element.align ? element.align : 'right';
          if (element.render === undefined) {
            element.render = (text, record, index) => {
              if (text === null || text === undefined) {
                return '--';
              } else {
                // NaN: Not a Number
                // isNaN()的缺点就在于 null、空格以及空串会被按照0来处理
                if (isNaN(text)) {
                  return text;
                } else {
                  return `${(Number(text) * 100).toFixed(element.toFixed ? element.toFixed : 2)}%`;
                }
              }
            };
          }
        }
        // 操作列
        if (element.type === 'operate') {
          const { operates } = element;
          element.render = (text, record, index) => {
            return (
              <div>
                {operates.map((item, index) => {
                  const { rules } = item;
                  let hide = true;
                  let disabled = true;
                  // 默认不同字段，条件之间是与关系，同字段，条件之间是或的关系（同字段的或关系未实现，需扩展），
                  // 当设置了relation是or时，不同字段条件之间的关系是或
                  // 处理隐藏逻辑
                  if (rules && rules.hide) {
                    if (rules.hide.relation === 'or') {
                      let tag = false;
                      rules.hide.items.forEach((eachRule) => {
                        // 处理不同字段之间的或关系
                        const value = record[eachRule.key];
                        const compare = eachRule.value;
                        const { relation } = eachRule;
                        for (let i = 0; i < compare.length; i++) {
                          switch (relation[i]) {
                            case '=':
                              if (value === compare[i]) tag = tag || true;
                              break;
                            case '!=':
                              if (value !== compare[i]) tag = tag || true;
                              break;
                          }
                        }
                      });
                      hide = tag;
                    } else {
                      rules.hide.items.forEach((eachRule) => {
                        // 处理不同字段之间的与关系
                        const value = record[eachRule.key];
                        const compare = eachRule.value;
                        const { relation } = eachRule;
                        let tag = false;
                        for (let i = 0; i < compare.length; i++) {
                          switch (relation[i]) {
                            case '=':
                              if (value === compare[i]) tag = true;
                              break;
                            case '!=':
                              if (value !== compare[i]) tag = true;
                              break;
                          }
                        }
                        if (tag === false) hide = false;
                      });
                    }
                  } else {
                    hide = false;
                  }
                  // 处理禁用逻辑
                  if (rules && rules.disabled) {
                    if (rules.disabled.relation === 'or') {
                      let tag = false;
                      rules.disabled.items.forEach((eachRule) => {
                        // 处理不同字段之间的与关系
                        const value = record[eachRule.key];
                        const compare = eachRule.value;
                        const { relation } = eachRule;

                        for (let i = 0; i < compare.length; i++) {
                          switch (relation[i]) {
                            case '=':
                              if (value === compare[i]) tag = true;
                              break;
                            case '!=':
                              if (value !== compare[i]) tag = true;
                              break;
                          }
                        }
                      });
                      disabled = tag;
                    } else {
                      rules.disabled.items.forEach((eachRule) => {
                        // 处理不同字段之间的与关系
                        const value = record[eachRule.key];
                        const compare = eachRule.value;
                        const { relation } = eachRule;
                        let tag = false;
                        for (let i = 0; i < compare.length; i++) {
                          switch (relation[i]) {
                            case '=':
                              if (value === compare[i]) tag = true;
                              break;
                            case '!=':
                              if (value !== compare[i]) tag = true;
                              break;
                          }
                        }
                        if (tag === false) disabled = false;
                      });
                    }
                  } else {
                    disabled = false;
                  }

                  if (item.title === '删除' || item.title === '回退') {
                    return (
                      !hide && (
                        <Popconfirm
                          key={index}
                          title={item.title === '删除' ? '确定删除？' : '确定回退？'}
                          icon={<ExclamationCircleOutlined />}
                          onConfirm={(e) => {
                            item.onClick(record, index);
                          }}
                          disabled={disabled}
                          //   onClick={(e)=> {
                          //     e.stopPropagation(); //阻止冒泡
                          //     item.onClick(record, index)
                          //   }
                          // }
                        >
                          <a disabled={disabled}>{item.title}</a>
                        </Popconfirm>
                      )
                    );
                  } else {
                    return (
                      !hide && (
                        <a
                          key={index}
                          onClick={(e) => {
                            e.stopPropagation(); // 阻止冒泡
                            item.onClick(record, index);
                          }}
                          disabled={disabled}
                        >
                          {item.title}
                        </a>
                      )
                    );
                  }
                })}
              </div>
            );
          };
        }
        // 显示数据涨跌柱
        if (element.type === 'columnView') {
          element.align = element.align ? element.align : 'right';
          element.render = (text, record) => this.handleCompareNum(text, element.dataIndex);
        }
        // 显示数据涨跌-盈红亏绿
        if (element.type === 'updownText') {
          element.align = element.align ? element.align : 'right';
          if (element.render === undefined) {
            element.render = (text, record, index) => {
              if (text === null || text === undefined) {
                return '--';
              } else {
                let value = Number(text);
                if (element.percent) {
                  value *= 100;
                  value = `${value.toFixed(element.toFixed ? element.toFixed : 2)}%`;
                } else {
                  value = value.toFixed(element.toFixed ? element.toFixed : 2);
                }
                return <span style={{ color: Number(text) < 0 ? colorArr.debtAndProfit.text[1] : colorArr.debtAndProfit.text[0] }}>{value}</span>;
              }
            };
          }
        }
        // 数据筛选
        if (element.type === 'filterCol') {
          element.filterDropdown = ({ setSelectedKeys, selectedKeys, confirm, clearFilters }) => {
            return this.renderFilterOptions({ setSelectedKeys, selectedKeys, confirm, clearFilters }, element);
          };
          element.onFilter = (value, record) => record[element.key].toString().toLowerCase().includes(value.toLowerCase());
          element.filterIcon = (filtered) => {
            return (
              <span style={{ display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
                <img style={{ width: '14px', height: '14px' }} src={filtered ? filterIconHover : filterIcon} />
              </span>
            );
          };
        }
        // 当scroll:{{x:'max-content'}}时，需要ellipsis时
        if (element.type === 'maxContent') {
          if (element.render === undefined) {
            element.render = (text, record, index) => {
              if (text === null || text === undefined) {
                return '--';
              } else {
                return (
                  <span style={{ display: 'inline-block', overflow: 'hidden', whiteSpace: 'nowrap', textOverflow: 'ellipsis', maxWidth: (element.width || 0) - 24 }}>{text}</span>
                );
              }
            };
          }
        }
        if (element.type === 'textTooltip') {
          if (element.render === undefined) {
            element.render = (text, record, index) => {
              if (text === null || text === undefined || text === '') {
                return '--';
              } else {
                return (
                  <span>
                    {text}
                    {element.tipTitle ? (
                      <Tooltip title={element.tipTitle} overlayClassName={'tableTipStyle'}>
                        &nbsp;
                        <QuestionCircleOutlined style={{ color: '#4D86FF' }} />
                      </Tooltip>
                    ) : (
                      ''
                    )}
                  </span>
                );
              }
            };
          }
        }
        // 日期格式转化 默认 'YYYY-MM-DD'
        if (element.type === 'date') {
          if (element.render === undefined) {
            const formatStr = element.formatStr || 'YYYY-MM-DD';
            element.render = (text, record, index) => {
              if (text === null || text === undefined || text === '') {
                return '--';
              } else {
                return moment(text).format(formatStr);
              }
            };
            if (!element.width) {
              element.width = 102;
            }
          }
        }
        // 处理所有没有值的情况
        if (element.render === undefined) {
          element.render = (text, record, index) => (text === null || text === undefined ? '--' : text);
        }
      });

    const initStatus = columns && dataSource; // 标记是否达到初始化状态(true:可以初始化表格，false：还未获取到数据)
    const tableInfo = {};
    if (expandedRowKeys != undefined) {
      tableInfo.expandedRowKeys = expandedRowKeys;
    }
    // 不共用父级表头
    if (!commonHeader) {
      tableInfo.expandedRowRender = (record) => {
        const nestedConfig = record.nestedConfig || {};
        nestedConfig.hidePage = nestedConfig.hidePage !== false;
        nestedConfig.scroll = { x: '100%', y: 300 };
        nestedConfig.loading = !!record.loading;
        // style={{width:fixedChild?"max-content":''}} 子表宽度定宽 小于父表 设置子表最大宽度适应 y轴滚动条贴合显示
        return (
          <div className={fixedChild ? classNames(nestedStyle.nestedTable, 'maat-nestedTable') : ''} style={{ width: fixedChild ? 'max-contant' : '' }}>
            <TableC
              {...nestedConfig}
              columns={this.props.childCols || nestedConfig?.columns} // 字典翻译 多个子表 只会翻译一个所以单独传入
              onChange={(pagination, filters, sorter) => nestedTableChange({ pagination, filters, sorter, record })}
            />
          </div>
        );
      };
    }
    return (
      <div className={nestedStyle.tableContainer + (this.state.multiHeader ? ' table-thead' : '')} style={{ width, textAlign: 'center' }} ref={'table'}>
        <Spin spinning={!initStatus} tip='加载中...'>
          {initStatus && (
            <BasicTable
              {...tableInfo}
              columns={columns}
              dataSource={dataSource}
              rowClassName={rowClassName}
              bigTable={bigTable}
              // components={components}
              scroll={scroll}
              onChange={onChange}
              rowKey={rowKey}
              loading={loading}
              locale={{
                emptyText: (
                  <div className={styles.emptyBox} style={{ height: '78px' }}>
                    <img src={pic} width={76} height={52} />
                    <span>暂无数据</span>
                  </div>
                ),
              }}
              bordered={bordered}
              showHeader={showHeader}
              onRow={onRow}
              rowSelection={rowSelection}
              expandable={
                // 子表
                {
                  expandedRowRender: tableInfo.expandedRowRender,
                  onExpand,
                  defaultExpandAllRows,
                  defaultExpandedRowKeys,
                  expandedRowKeys: tableInfo.expandedRowKeys,
                }
              }
              footer={footer}
              pagination={
                hidePage
                  ? false
                  : {
                      total, // 数据总数
                      showTotal: (totalNum) => `共计 ${totalNum} 条`, // 用于显示数据总量和当前数据顺序
                      defaultCurrent, // 默认当前页数
                      current, // 实时更新当前页码
                      pageSize, // 每页条数
                      pageSizeOptions, // 指定每页可以显示多少条
                      showSizeChanger: true, // 是否可以改变 pageSize
                      onShowSizeChange, // pageSize 变化的回调
                      hideOnSinglePage: false, // 只有一页时，不隐藏分页
                      onChange: onPageChange,
                      size,
                      simple,
                      showQuickJumper:
                        size == 'small'
                          ? ''
                          : {
                              goButton: <PrimaryGhostC title='确定' style={{ marginLeft: '10px' }} />,
                            },
                    }
              }
            />
          )}
        </Spin>
      </div>
    );
  }
}

// props类型
// columns或dataSource为undefined时，为loading状态，为空数组时，显示“暂无数据”
NestedTableC.propsTypes = {
  columns: PropTypes.array, // 列信息(title和key是必填)（支持设置三类type:1)money 2)number 3)rate 4)operate，其他有关样式上的需求，自行添加render）
  dataSource: PropTypes.array, // 数据源
  defaultCurrent: PropTypes.number, // 当前页码
  total: 0, // 数据总量
  pageSize: 20, // 一页数量量
  pageSizeOptions: PropTypes.array, // 一页数据量的可选值
  onShowSizeChange: (current, size) => {}, // pageSize变化时的回调
  onPageChange: (page, pageSize) => {}, // 页码改变的回调，参数是改变后的页码及每页条数
  scroll: undefined, // 横向或纵向滚动条
  hidePage: false, // 默认不隐藏页码
  width: PropTypes.string, // 表格宽度
  onChange: () => {}, // 表格所有的操作变化时 回调
  bordered: false, // 是否展示外边框和列
  onExpand: (expanded, record) => {}, // 点击展开图标时触发
  onRow: (record) => {}, // 行属性
  expandedRowKeys: PropTypes.array, // 展开的节点
  rowKey: PropTypes.oneOfType([PropTypes.string, PropTypes.func]), // 设置唯一的key
  current: PropTypes.number, // 实时更新当前页码
  size: PropTypes.string, // 分页器尺寸
  rowClassName: PropTypes.oneOfType([
    // 设置行样式
    PropTypes.string,
    PropTypes.func,
  ]),
  loading: PropTypes.bool, // 加载中状态
  rowSelection: PropTypes.object, // 表格行是否可选择
  collapsed: PropTypes.bool, // 单元格省略时必须入参 true/false
  showHeader: PropTypes.bool, // 是否展示表头
  footer: () => {}, // 表格底部内容
  commonHeader: PropTypes.bool, // 是否公用表头
  nestedTableChange: () => {}, // 子表onChange
  fixedChild: PropTypes.bool, // 子表格固定宽度展示
  defaultExpandAllRows: PropTypes.bool, // 默认是否展开子表
  defaultExpandedRowKeys: PropTypes.array, // 默认展开的子节点
  bigTable: PropTypes.bool, // 大数据表格
};

export default connect(({ globalM }) => ({ globalM }))(NestedTableC);
